package convert

import (
	"errors"
	"math"
	"strconv"
)

// IntToInt8 将int类型转换为int8类型，检查是否发生溢出
func IntToInt8(value int) (int8, error) {
	if int64(value) < math.MinInt8 || int64(value) > math.MaxInt8 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return int8(value), nil // 转换并返回int8类型的值，如果没有错误则返回nil
}

// IntToInt16 将int类型转换为int16类型，检查是否发生溢出
func IntToInt16(value int) (int16, error) {
	if int64(value) < math.MinInt16 || int64(value) > math.MaxInt16 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return int16(value), nil // 转换并返回int16类型的值，如果没有错误则返回nil
}

// IntToInt32 将int类型转换为int32类型，检查是否发生溢出
func IntToInt32(value int) (int32, error) {
	if int64(value) < math.MinInt32 || int64(value) > math.MaxInt32 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return int32(value), nil // 转换并返回int32类型的值，如果没有错误则返回nil
}

// IntToInt64 将int类型转换为int64类型，不需要检查溢出
func IntToInt64(value int) (int64, error) {
	return int64(value), nil // 直接转换并返回int64类型的值，如果没有错误则返回nil
}

// IntToUint 将int类型转换为uint类型，检查是否为负数
func IntToUint(value int) (uint, error) {
	if value < 0 {
		return 0, errors.New("negative value cannot be converted to uint") // 如果是负数，返回错误
	}
	return uint(value), nil // 转换并返回uint类型的值，如果没有错误则返回nil
}

// IntToUint8 将int类型转换为uint8类型，检查是否为负数或溢出
func IntToUint8(value int) (uint8, error) {
	if value < 0 {
		return 0, errors.New("negative value cannot be converted to uint8") // 如果是负数，返回错误
	}
	if uint64(value) > math.MaxUint8 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return uint8(value), nil // 转换并返回uint8类型的值，如果没有错误则返回nil
}

// IntToUint16 将int类型转换为uint16类型，检查是否为负数或溢出
func IntToUint16(value int) (uint16, error) {
	if value < 0 {
		return 0, errors.New("negative value cannot be converted to uint16") // 如果是负数，返回错误
	}
	if uint64(value) > math.MaxUint16 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return uint16(value), nil // 转换并返回uint16类型的值，如果没有错误则返回nil
}

// IntToUint32 将int类型转换为uint32类型，检查是否为负数或溢出
func IntToUint32(value int) (uint32, error) {
	if value < 0 {
		return 0, errors.New("negative value cannot be converted to uint32") // 如果是负数，返回错误
	}
	if uint64(value) > math.MaxUint32 {
		return 0, errors.New("overflow occurred during conversion") // 如果发生溢出，返回错误
	}
	return uint32(value), nil // 转换并返回uint32类型的值，如果没有错误则返回nil
}

// IntToUint64 将int类型转换为uint64类型，检查是否为负数
func IntToUint64(value int) (uint64, error) {
	if value < 0 {
		return 0, errors.New("negative value cannot be converted to uint64") // 如果是负数，返回错误
	}
	return uint64(value), nil // 转换并返回uint64类型的值，如果没有错误则返回nil
}

// IntToFloat32 将int类型转换为float32类型，不需要检查溢出
func IntToFloat32(value int) (float32, error) {
	return float32(value), nil // 直接转换并返回float32类型的值，如果没有错误则返回nil
}

// IntToFloat64 将int类型转换为float64类型，不需要检查溢出
func IntToFloat64(value int) (float64, error) {
	return float64(value), nil // 直接转换并返回float64类型的值，如果没有错误则返回nil
}

// IntToString 将int类型转换为string类型
func IntToString(value int) string {
	return strconv.Itoa(value) // 使用strconv包的Itoa函数转换并返回string类型的值
}

// IntToBool 将int类型转换为bool类型，非零值转换为true，零值转换为false
func IntToBool(value int) bool {
	return value != 0 // 根据值是否为零来转换为bool类型
}
